package com.peng.immodule.util;

import android.util.Base64;

import java.security.MessageDigest;
import java.util.Arrays;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * Created by M_genius on 2018/3/6 15:57.
 * 描述：该类主要实现数据的加密和解密操作
 *  Cipher 类为加密和解密提供密码功能
 *  1、Cipher 类是一个引擎类，它需要通过 getInstance()工厂方法来实例化对象。
 *
 *  2、Cipher 类常量
 *      用于将 Cipher 初始化为解密模式的常量
 *      public final static int DECRYPT_MODE
 *
 *      用于将 Cipher 初始化为加密模式的常量
 *      public final static int ENCRYPT_MODE
 *
 *  3、获取 Cipher 对象
 *      可以通过指定 转换模式 的方式获得实例化对象
 *      参数String transformation 的格式是 "算法/工作模式/填充模式"，不同的算法支持不同的工作模式以及填充模式
 *      public static Cipher getInstance(String transformation)
 *      eg、Cipher c = Cipher.getInstance("DES");
 *      上述实例化操作是一种最为简单的实现，并没有考虑DES分组算法的工作模式和填充模式，可通过以下方式对其设定：
 *      Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
 *
 *      也可以在制定 转换模式 的同时制定该 转换模式的提供者
 *      public static Cipher getInstance(String transformation, String provider)
 *
 */

public class CryptoUtils {

    Cipher cipher = null;
    Cipher decipher = null;

    // 标识使用什么算法的常量
    public static final int ALGORIGHM_DES = 0;
    public static final int ALGORIGHM_AES = 1;

    byte[] keyBytes = new byte[]{74, 111, 104, 110, 115, 111, 110, 77, 97, 74, 105, 70, 97, 110, 103, 74, 101, 114, 118, 105, 115, 76, 105, 117, 76, 105, 117, 83, 104, 97, 111, 90};

    String key = "TongliforniaJohnson";

    static final String HEXES = "0123456789ABCDEF";

    public CryptoUtils() {
    }

    public void init(int var1) {
        if(var1 == 0) {
            initDES();
        } else {
            initAES();
        }

    }

    public void initDES() {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("md5");
            byte[] byteArray = messageDigest.digest(key.getBytes("utf-8"));
            keyBytes = Arrays.copyOf(byteArray, 24);
            int var3 = 0;

            for(int var4 = 16; var3 < 8; keyBytes[var4++] = keyBytes[var3++]) {
                ;
            }

            SecretKeySpec var6 = new SecretKeySpec(keyBytes, "DESede");
            IvParameterSpec var7 = new IvParameterSpec(new byte[8]);

            /**
             *  加解密说明地址：
             *      http://blog.csdn.net/lz710117239/article/details/71119032
             * 1、通过指定转换模式的方式获得实例化对象，参数String transformation的格式是 "算法/工作模式/填充模式"
             *      Cipher c = Cipher.getInstance("DES");
             *      上述实例化操作是一种最为简单的实现，并没有考虑DES分组算法的工作模式和填充模式，可通过以下方式对其设定：
             *      Cipher.getInstance("DESede/CBC/PKCS5Padding");
             *
             *
             *
             */
            cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
            cipher.init(1, var6, var7);

            decipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
            decipher.init(2, var6, var7);
            //EMLog.d("encrypt", "initital for DES");
        } catch (Exception var5) {
            var5.printStackTrace();
        }

    }

    public void initAES() {
        try {
            cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            SecretKeySpec var1 = new SecretKeySpec(keyBytes, "AES");
            cipher.init(1, var1);
            decipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            decipher.init(2, var1);
            //EMLog.d("encrypt", "initital for AES");
        } catch (Exception var2) {
            var2.printStackTrace();
        }

    }

    /**
     * Base64 加密
     * @param var1
     * @return
     * @throws Exception
     */
    public String encryptBase64String(String var1) throws Exception {
        byte[] var2 = encrypt(var1);
        return new String(Base64.encode(var2, 0));
    }

    /**
     * Base64 解密
     * @param var1
     * @return
     * @throws Exception
     */
    public String decryptBase64String(String var1) throws Exception {
        byte[] var2 = Base64.decode(var1, 0);
        byte[] var3 = decrypt(var2);
        return new String(var3, "UTF-8");
    }

    public byte[] encrypt(String var1) throws Exception {
        // 根据指定的 decode 编码返回某字符串在该编码下的 byte 数组
        byte[] var2 = var1.getBytes("UTF-8");
        // 按单部分操作加密或解密数据，或者结束一个多部分操作
        byte[] var3 = cipher.doFinal(var2);
        return var3;
    }

    public byte[] encrypt(byte[] var1) throws Exception {
        return cipher.doFinal(var1);
    }

    public byte[] decrypt(byte[] var1) throws Exception {
        return decipher.doFinal(var1);
    }

    public static String getHex(byte[] var0) {
        if(var0 == null) {
            return null;
        } else {
            StringBuilder var1 = new StringBuilder(2 * var0.length);
            byte[] var2 = var0;
            int var3 = var0.length;

            for(int var4 = 0; var4 < var3; ++var4) {
                byte var5 = var2[var4];
                var1.append("0123456789ABCDEF".charAt((var5 & 240) >> 4)).append("0123456789ABCDEF".charAt(var5 & 15));
            }

            return var1.toString();
        }
    }

    public static byte[] fromHexString(String var0) {
        int var1 = var0.length();
        byte[] var2 = new byte[var1 / 2];

        for(int var3 = 0; var3 < var1; var3 += 2) {
            var2[var3 / 2] = (byte)((Character.digit(var0.charAt(var3), 16) << 4) + Character.digit(var0.charAt(var3 + 1), 16));
        }

        return var2;
    }
}
